/// Canonicalization mode for [`Document.c14n`]
pub enum C14NMode {
  /// [XML_C14N_1_0](https://www.w3.org/TR/2001/REC-xml-c14n-20010315)
  Mode1_0,
  /// [XML_C14N_1_1](https://www.w3.org/TR/xml-c14n11/)
  Mode1_1,
  /// [XML_C14N_EXCLUSIVE_1_0](https://www.w3.org/TR/xml-exc-c14n/)
  ModeExclusive1_0(Vec<CString>),
}
impl C14NMode {
  fn as_c_int(&self) -> c_int {
    match self {
      C14NMode::Mode1_0 => xmlC14NMode_XML_C14N_1_0 as c_int,
      C14NMode::Mode1_1 => xmlC14NMode_XML_C14N_1_1 as c_int,
      C14NMode::ModeExclusive1_0(_) => xmlC14NMode_XML_C14N_EXCLUSIVE_1_0 as c_int,
    }
  }
}

let buffer = xmlBufferCreate();
let c14n_res = xmlC14NExecute(
        …,
        xmlOutputBufferCreateBuffer(buffer, ptr::null_mut()),
      );
let result = xmlBufferContent(buffer);
let c_string = CStr::from_ptr(result as *const c_char);
let node_string = c_string.to_string_lossy().
xmlBufferFree(
Ok(node_string)

type IsVisibleCallback = Box<dyn Fn(&RoNode, &RoNode) -> bool>;

// thin pointer wrapper that calls supplied the callback instead
unsafe extern "C" fn _is_visible_wrapper(
  data: *mut c_void,
  node: xmlNodePtr,
  parent: xmlNodePtr,
) -> c_int {
  let callback = unsafe { &mut *(data as *mut IsVisibleCallback) };
 // handling of parent nodes etc.
 // …
 (callback)(&RoNode(node), &RoNode(parent))) as c_int
}

impl Document{
  /// Canonicalizes the XML document according to the W3C XML Canonicalization specification.
  ///
  /// This method produces a canonical form of the XML document, which is useful for digital signatures
  /// and document comparison. The canonicalization process ensures consistent representation of the XML content.
    pub fn c14n(
    &self,
    mode: C14NMode,
    with_comments: bool,
  ) -> Result<String, ()> {
    self.c14n_with_visibility_callback(None, mode, with_comments)
  }

  /// Canonicalizes the document with an optional visibility callback
  ///
  /// `is_visible_callback(node: &RoNode, parent: &RoNode)` is called for every
  /// node having a parent, returning true if the node should be included in the
  /// canonicalized output.
  pub fn c14n_with_visibility_callback(
    &self,
    is_visible_callback: Option<IsVisibleCallback>,
    mode: C14NMode,
    with_comments: bool,
  ) -> Result<String, ()> {
      // boxes the callback so it can be passed as a void pointer to [`_is_visible_wrapper`]
      let (is_visible_fn, mut user_data) = match is_visible_callback {
        Some(f) => (
          Some(_is_visible_wrapper as unsafe extern "C" fn(_, _, _) -> _),
          Some(Box::into_raw(f)),
        ),
        None => (None, None),
      };
      let c14n_res = xmlC14NExecute(
        self.doc_ptr(),
        is_visible_fn,
        user_data
          .as_mut()
          .map(|s| ptr::from_mut(s))
          .unwrap_or(ptr::null_mut()) as *mut c_void,
        mode.as_c_int(),
        inclusive_ns_prefixes,
        with_comments as c_int,
        xmlOutputBufferCreateBuffer(buffer, ptr::null_mut()),
      );
      // …
  }
}

let input = r#"<ns1:root><ns2:foo x="1"  a="2"/><!--cmt--><a/><b/></ns1:root>"#;
let callback = |_node: &RoNode, _parent: &RoNode| {
    !(_parent.get_name() == "ns1:root" && _node.get_name() == "a")
  };
  let c14n_result = doc.c14n_with_visibility_callback(
    Some(Box::new(callback)),
    libxml::tree::document::C14NMode::Mode1_1,
    false,
  );